package com.lagou.factory;

import com.lagou.annotation.Autowire;
import com.lagou.annotation.Repository;
import com.lagou.annotation.Service;
import com.lagou.annotation.Transactional;
import com.lagou.dao.impl.JdbcAccountDaoImpl;
import com.lagou.factory.ProxyFactory;
import com.lagou.service.impl.TransferServiceImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerImpl;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.omg.CORBA.OBJ_ADAPTER;

import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * <pre>
 * 描述：TODO
 * </pre>
 *
 * @类名：com.lagou.factory.BeanFactory
 * @作者 mengwei
 * 创建日期：2020/10/13 15:34
 */
public class AnnotationBeanFactory {

    /**
     * 任务一：读取解析xml，通过反射技术实例化对象并且存出待用（map集合）
     * 任务二：对我提供实例对象的接口
     */

    private static Map<String,Object> map=new HashMap<String,Object>();

//    当做二级缓存，存储原始类信息，为了解决代理生成的类获取不到  原始字段信息
    private static Map<String,Object> beforeProxyMap=new HashMap<>();

    static {
        /**
         * 初始化的时候解析xml，通过反射实例化对象，并且放入map
         */

        InputStream resourceAsStream = AnnotationBeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(resourceAsStream);
//            获得注解扫描配置目录
            Element annotationScan = (Element) document.getRootElement().selectSingleNode("//annotation-scan");
//                <annotation-scan package="com.lagou"/>
            String packageUrl = annotationScan.attributeValue("package");
            List<Class<?>> classes = getClasses(packageUrl);

//            将使用注解的对象添加到sprig容器中
            registClassAnno(classes);

//            添加完所有的bean后，解析bean中的对象@Autowire注解
            registParamAnno();
//          对method进行注解
            registMethod();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private static <T> void registMethod() {
        for (String key : map.keySet()) {
            T o = (T) map.get(key);
            Method[] methods = o.getClass().getMethods();

            for (Method method : methods) {
                if (null != method.getAnnotation(Transactional.class)){
//                    如果有Transactional注解，则生成代理类
                    map.put(key,TransactionalProxyFactory.newInstance().getProxy(o));

                }
            }
        }
    }


    //    处理参数注解
    private static <T> void registParamAnno() throws IllegalAccessException {

        for (String key : beforeProxyMap.keySet()) {
            T beforeProxyObj = (T) beforeProxyMap.get(key);
            T proxyObj =(T)  map.get(key);
            Field[] declaredFields = beforeProxyObj.getClass().getDeclaredFields();
            Field[] proxyObjFields = proxyObj.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
//                暴力破解，使其他对象可以访问该属性
                declaredField.setAccessible(true);
                Annotation[] annotations = declaredField.getAnnotations();

                if (annotations.length >0){
                    for (Annotation annotation : annotations) {
                        if (annotation instanceof Autowire){
//                            如果是autowire注解

                            String value = ((Autowire) annotation).value();
                            declaredField.set(proxyObj,map.get(value));

                        }
                    }

                }
            }


        }


    }

    private static <T> void registClassAnno(List<Class<?>> classes) throws IllegalAccessException, InstantiationException {
        for (Class<?> aClass : classes) {
//            if (aClass.isMemberClass()) System.out.println(aClass.getSimpleName());
            if ( aClass.isInterface() || aClass.isAnnotation()) continue;
            Annotation[] aClassAnnotations = aClass.getAnnotations();
            if (aClassAnnotations.length >0){

                Object object =  aClass.newInstance();
                String value = null;
                for (Annotation aClassAnnotation : aClassAnnotations) {

                    if (aClassAnnotation instanceof Service){
//                            如果是 Service，Repository，直接将其注入到spring容器中
                        value= ((Service) aClassAnnotation).value();
                        if ("".equals(value.trim())){
//                                如果没有指定value值，则使用SimpleName作为bean名
                            value = aClass.getName();
                        }
                    }else if (aClassAnnotation instanceof Repository){
//                            如果是 Service，Repository，直接将其注入到spring容器中
                        value = ((Repository) aClassAnnotation).value();
                        if ("".equals(value.trim())){
//                                如果没有指定value值，则使用SimpleName作为bean名
                            value = aClass.getName();
                        }
                    }

                    map.put(value, object);
                    beforeProxyMap.put(value, object);
                }


            }

        }
    }


    /**
     * 从包package中获取所有的Class
     * @param packageName
     * @return
     */
    public static List<Class<?>> getClasses(String packageName){

        //第一个class类的集合
        List<Class<?>> classes = new ArrayList<Class<?>>();
        //是否循环迭代
        boolean recursive = true;
        //获取包的名字 并进行替换
        String packageDirName = packageName.replace('.', '/');
        //定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            //循环迭代下去
            while (dirs.hasMoreElements()){
                //获取下一个元素
                URL url = dirs.nextElement();
                //得到协议的名称
                String protocol = url.getProtocol();
                //如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    //获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    //以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)){
                    //如果是jar包文件
                    //定义一个JarFile
                    JarFile jar;
                    try {
                        //获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        //从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        //同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            //获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            //如果是以/开头的
                            if (name.charAt(0) == '/') {
                                //获取后面的字符串
                                name = name.substring(1);
                            }
                            //如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                //如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    //获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                //如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive){
                                    //如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        //去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            //添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }
    /**
     * 以文件的形式来获取包下的所有Class
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes){
        //获取此包的目录 建立一个File
        File dir = new File(packagePath);
        //如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        //如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            //自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        //循环所有文件
        for (File file : dirfiles) {
            //如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(),
                        file.getAbsolutePath(),
                        recursive,
                        classes);
            }
            else {
                //如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    //添加到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static Object getBean(String beanId) {
        return map.get(beanId);
    }
}
